🖥 Новинка в Python 3.14: t-строки — типобезопасные f-строки

Python 3.14 вводит t"..." — новый синтаксис для строк, ориентированных на безопасность типов и интеграцию с системами шаблонов, SQL, HTML и др.

🔹 Что такое t-строка?
t"..." — это как f"...", но:

- интерполяция ограничена и контролируема;
- поддерживается строгое соответствие шаблону;
- можно передавать переменные явно, предотвращая SQL-инъекции и XSS.

🔸 Пример:

name = "Alice"
greeting = t"Hello, {name}!"  # t-строка
Вместо немедленной подстановки, как в f"...", t"..." создает шаблон с выражениями как параметрами.

🔐 Зачем это нужно?
✅ Безопасность при генерации SQL, HTML, JSON

✅ Улучшение инструментов и проверки типов (через static analysis)

✅ Контроль над контекстом исполнения (больше нельзя просто вставить переменную как есть — нужно передать её явно)

📦 Использование:
t-строки — это первый шаг к "template string literals" как в TypeScript.

Можно использовать с функциями:

def html(template: T[str]) -> SafeHTML:
    ...

html(t"<div>{user_input}</div>")

💡 Почему это важно?
Старый код:

f"SELECT * FROM users WHERE name = '{user_name}'"
может привести к SQL-инъекциям и XSS.
t-строки — безопасная альтернатива с встроенной защитой.

🛡 Пример: безопасный HTML

template = t"<p>{user_input}</p>"
html_output = html(template)
# <p>&lt;script&gt;alert('bad')&lt;/script&gt;</p>

Функция html() может вернуть не просто строку, а полноценный HTMLElement.
Больше никакой "грязи" — всё чисто и типобезопасно.

🔍 Работа с шаблоном
t-строки позволяют получить доступ к содержимому:

template = t"Hello {name}!"
template.strings      # ("Hello ", "!")
template.values       # (name,)
template.interpolations[0].format_spec  # ">8"

Можно и вручную собрать шаблон:

Template("Hello ", Interpolation(value="World", expression="name"), "!")

🚀 Вывод:
t"..." — шаг к безопасным шаблонам и типизации строк в Python.
Готовься к будущему Python — безопасному по умолчанию.

📌 Подробнее здесь

@pythonl

🖥Задача: "Динамическое кэширование с ограничением памяти и частотой запросов"

🔖 Условие:

Реализуйте класс SmartCache, который работает следующим образом:

- Метод put(key: str, value: Any):
- Сохраняет значение по ключу.
- Если суммарный объем памяти, занимаемый всеми элементами, превышает лимит (например, 10 MB), автоматически удаляются наименее "ценные" элементы.

- Метод get(key: str) -> Any:
- Возвращает значение по ключу.
- Увеличивает счётчик использования элемента.
- Если элемент отсутствует — возвращает None.

Что значит "ценность" элемента:
- Ценность = количество обращений (`hit count`) к элементу.
- При очистке кэша сначала удаляются элементы с наименьшим количеством обращений.

Ограничения:
- Класс должен корректно считать объём памяти, занимаемый элементами.
- Нужно учитывать, что элементы могут быть сложными структурами (`dict`, list, вложенные объекты).
- Решение должно быть эффективным: операции должны быть быстрыми даже при большом количестве элементов.

---

▪️ Подсказки:

- Для оценки размера объектов можно использовать модуль sys.getsizeof, но для сложных вложенных структур нужен рекурсивный подсчет.
- Для хранения частоты обращений стоит использовать дополнительную структуру данных (`collections.Counter` или `dict`).
- При очистке лучше сначала группировать элементы по "ценности", а затем удалять самые "дешевые".

---

▪️ Что оценивается:

- Умение работать с ограничениями по памяти.
- Аккуратная обработка ссылок и размеров объектов.
- Эффективность очистки кэша.
- Чистота и читаемость кода.

---

▪️ Разбор возможного решения:

Идея архитектуры:

- Храним:
- storage: словарь {key: value}.
- hits: счётчик {key: hit_count}.
- size: общий размер всех объектов.
- При put():
- Добавляем элемент.
- Пересчитываем суммарный размер.
- Если размер превышает лимит:
- Удаляем наименее популярные элементы до тех пор, пока не уложимся в лимит.
- При get():
- Увеличиваем hit_count элемента.
- Возвращаем значение или None.

Оценка размера объектов:

- Простого sys.getsizeof недостаточно для коллекций.
- Нужна функция, рекурсивно подсчитывающая размер всех вложенных объектов.

Мини-пример функции подсчета размера:

import sys

def deep_getsizeof(obj, seen=None):
    """Рекурсивно считает память объекта и его вложенных объектов"""
    size = sys.getsizeof(obj)
    if seen is None:
        seen = set()
    obj_id = id(obj)
    if obj_id in seen:
        return 0
    seen.add(obj_id)

    if isinstance(obj, dict):
        size += sum([deep_getsizeof(v, seen) + deep_getsizeof(k, seen) for k, v in obj.items()])
    elif isinstance(obj, (list, tuple, set, frozenset)):
        size += sum(deep_getsizeof(i, seen) for i in obj)
    return size

Мини-пример интерфейса `SmartCache`:

class SmartCache:
    def __init__(self, max_size_bytes):
        self.max_size = max_size_bytes
        self.storage = {}
        self.hits = {}
        self.total_size = 0

    def put(self, key, value):
        # добавить логику добавления и очистки при переполнении
        pass

    def get(self, key):
        # увеличить hit_count и вернуть значение
        pass

🔖 Дополнительные вопросы:

- Как ускорить очистку кэша без полного перебора всех элементов?
- Как сделать потокобезопасную версию кэша?
- Как адаптировать SmartCache для распределённой архитектуры (кэш между несколькими машинами)?

@python_job_interview

🖥 В этой статье автор делится опытом компиляции первой стабильной версии Python 1.0, выпущенной 27 января 1994 года, используя современные инструменты виртуализации!

🌟 Для этого автор использует контейнеризацию с помощью Podman, разворачивая старую версию Debian (Debian 4.0) для создания подходящей среды. В процессе описываются шаги по настройке окружения, установке необходимых инструментов сборки и решению возникающих проблем, таких как несовместимость современных протоколов SSL/TLS при загрузке исходных кодов. После успешной компиляции Python 1.0 автор исследует его возможности, отмечая наличие высокоуровневых структур данных и поддержку работы с процессами, текстом, файлами и сетью, а также указывает на некоторые забавные особенности и ограничения той эпохи.

🔗 Ссылка: *клик*

@python_job_interview

📝 Как составить резюме, чтобы попасть в Magnificent 7: анализ кейса

Недавно инженер поделился своим резюме, которое помогло ему получить предложение работы от одной из rjvgfybb Magnificent 7 (Apple, Microsoft, Google, Amazon, Meta, Nvidia, Tesla).

Magnificent 7 (в переводе — «Великолепная семёрка») — это современное неофициальное название семи крупнейших и самых влиятельных технологических компаний США, которые лидируют на фондовом рынке, в инновациях и в масштабе бизнеса.

Разберём, что сделало его резюме успешным и чему можно научиться.

📌 Главные выводы из резюме:

1. Фокус на достижениях, а не обязанностях.

Многие кандидаты в резюме просто перечисляют, *что они делали*, например:

- “Разрабатывал API”
- “Поддерживал базу данных”
- “Писал скрипты для автоматизации”

⚠️ Это описывает обязанности, но не показывает ценность или результат работы.

В успешном резюме инженер вместо этого написал, чего он достиг благодаря своей работе:

✅ “Разработал API, который сократил время обработки данных на 30%”
✅ “Оптимизировал запросы к базе данных, уменьшив среднее время ответа с 2 секунд до 0.5 секунд”
✅ “Автоматизировал процесс деплоя, снизив количество ошибок на 15%”

Такой подход показывает, как конкретно ваша работа помогла команде или бизнесу.
Работодатель видит результаты, которые вы приносите, а не просто описание того, что вы делали.

💡 Почему это важно?

Big Tech-компании ищут инженеров, которые:

- Умеют оценивать влияние своей работы
- Думают о метриках успеха
- Приносят измеримый результат

Если в резюме нет цифр, улучшений или влияния на процесс — работодатель сам должен это додумывать.
А успешное резюме снимает вопросы и сразу показывает: “Вот что я сделал, вот как я улучшил продукт/процесс/результат.”


2. Лаконичность и компактность.

✅ 1 страница
✅ Чёткая структура: “Опыт”, “Навыки”, “Образование”
✅ Без фото, графиков, цветных рамок — чистый текст

3. Цифры везде, где это возможно.

Любое достижение сопровождается конкретной метрикой: улучшение производительности, сокращение времени, рост количества пользователей.
Даже небольшие улучшения указаны численно.

4. Поддержка через проекты с открытым кодом.

Инженер приложил ссылку на GitHub с реальными проектами — это усилило доверие к нему Как с специалисту.

5. Навыки — только релевантные вакансии.

В разделе Skills нет «MS Word» или «PowerPoint».
Только языки, технологии, инструменты, которые нужны для позиции (Python, Kubernetes, CI/CD, etc.).

6. Интерншипы и стажировки — это опыт.

Каждый опыт, даже в рамках стажировки, описан с результатами.
Вакансии в топ-компаниях ценят любую практику в реальной команде.

---

🎯 Что важно для Big Tech:

✅ Результаты > Задачи.
✅ Цифры.
✅ 1 страница.
✅ GitHub/портфолио.
✅ Релевантные навыки.

---

🔥 Совет:

Ваше резюме — это реклама вас как продукта.
Покажите пользу, которую вы можете принести, а не просто список обязанностей.

➡️ Статья

👩‍💻 Хочется выделить свой Github профиль для вашего резюме?

🔥 Просто скачайте этот скрипт и он создаст вам фейковую активность путем отправки множества пустых коммитов в случайном количестве!

🔐 Лицензия: Apache-2.0

🖥 Github

@python_job_interview